package com.JingYan.HuaWei;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @program: JingYan
 * @ClassName: JK008.java
 * @author: DongJiaQi
 * @version: 1.0.0
 * @Description: 华为机考 比赛评分
 * @createTime 2024年04月10日 14:49:00
 */
public class JK008 {
    /**
     * 一个有N个选手参加比赛，选手编号为1~N（3<=N<=100），有M（3<=M<=10）个评委对选手进行打分。打分规则为每个评委对选手打分，最高分10分，最低分1分。
     * 请计算得分最多的3位选手的编号。如果得分相同，则得分高分值最多的选手排名靠前(10分数量相同，则比较9分的数量，以此类推，用例中不会出现多个选手得分完全相同的情况)。
     * 输入描述:
     * 第一行为半角逗号分割的两个正整数，第一个数字表示M（3<=M<=10）个评委，第二个数字表示N（3<=N<=100）个选手。
     * 第2到M+1行是半角逗号分割的整数序列，表示评委为每个选手的打分，0号下标数字表示1号选手分数，1号下标数字表示2号选手分数，依次类推。
     * 输出描述:
     * 选手前3名的编号。
     * 注：若输入为异常，输出-1，如M、N、打分不在范围内。
     * 示例1：
     * 输入
     * 4,5
     * 10,6,9,7,6
     * 9,10,6,7,5
     * 8,10,6,5,10
     * 9,10,8,4,9
     * 输出
     * 2,1,5
     * 说明
     * 第一行代表有4个评委，5个选手参加比赛
     * 矩阵代表是4*5，每个数字是选手的编号，每一行代表一个评委对选手的打分排序，
     * 2号选手得分36分排第1，1号选手36分排第2，5号选手30分(2号10分值有3个，1号10分值只有1个，所以2号排第一)
     * 示例2：
     * 输入
     * 2,5
     * 7,3,5,4,2
     * 8,5,4,4,3
     * 输出
     * -1
     * 说明：只有2个评委，要求最少为3个评委
     * 示例3：
     * 输入
     * 4,2
     * 8,5
     * 5,6
     * 10,4
     * 8,9
     * 输出
     * -1
     * 说明：只有2名选手参加，要求最少为3名
     * 示例4：
     * 输入
     * 4,5
     * 11,6,9,7,8
     * 9,10,6,7,8
     * 8,10,6,9,7
     * 9,10,8,6,7
     * 输出
     * -1
     * 说明：第一个评委给第一个选手打分11，无效分数
     */
    public static class Solution {
        private int no;
        private List cjList;
        //得分数
        private Map dfs;
        //总分
        private int zf;

        public int getNo() {
            return no;
        }

        public void setNo(int no) {
            this.no = no;
        }


        public Map getDfs() {
            return dfs;
        }

        public void setDfs(Map dfs) {
            this.dfs = dfs;
        }

        public List getCjList() {
            return cjList;
        }

        public void setCjList(List cjList) {
            this.cjList = cjList;
        }

        public int getZf() {
            return zf;
        }

        public void setZf(int zf) {
            this.zf = zf;
        }

        public Solution() {
        }
        public Solution(int no, List<Integer> cjList) {
            this.no=no;
            cjList.sort(Comparator.comparingInt(o -> (int) o).reversed());
            this.cjList = cjList;
            this.zf = cjList.stream().mapToInt(Integer::intValue).sum();
            this.dfs = new HashMap();
            for (int i = 0; i < cjList.size(); i++) {
                if (dfs.containsKey(cjList.get(i))) {
                    dfs.put(cjList.get(i), (int) dfs.get(cjList.get(i)) + 1);
                } else {
                    dfs.put(cjList.get(i), 1);
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] split = sc.nextLine().split(",");
        String pwn = split[0];
        int pwnIne = Integer.parseInt(pwn);
        if (pwnIne < 3 || pwnIne > 10) {
            System.out.println(-1);
            return;
        }
        String xsn = split[1];
        int xsnInt = Integer.parseInt(xsn);
        if (xsnInt < 3 || xsnInt > 100) {
            System.out.println(-1);
            return;
        }

        List<List<String>> cjList = new ArrayList<>();
        for (int i = 0; i < pwnIne; i++) {
            String[] df = sc.nextLine().split(",");
            //选手分数量不对
            if (df.length != xsnInt) {
                System.out.println(-1);
                return;
            }
            cjList.add( Arrays.asList(df));
        }
        List<Solution> xspxList = new ArrayList<>();
        for (int i = 0; i < xsnInt ; i++) {

            List<Integer> xscjList = new ArrayList<>();
            for (List<String> pwcjList : cjList) {
                int s = Integer.parseInt(pwcjList.get(i));
                if (s < 1 || s > 10) {
                    System.out.println(-1);
                    return;
                }
                xscjList.add(s);

            }
            Solution solution = new Solution(i + 1, xscjList);
            xspxList.add(solution );

        }
        String str = xspxList.stream().sorted(
                Comparator.comparingInt(Solution::getZf).reversed()
                        .thenComparing((a, b) -> {
                            Iterator aIterator = a.getDfs().entrySet().iterator();
                            Iterator bIterator = b.getDfs().entrySet().iterator();
                            while (aIterator.hasNext()) {
                                Map.Entry aEntry = (Map.Entry) aIterator.next();
                                Map.Entry bEntry = (Map.Entry) bIterator.next();
                                int cha = (int) bEntry.getValue() - (int) aEntry.getValue();
                                if (cha != 0) {
                                    return cha;
                                }

                            }
                            return -1;
                        })).limit(3).map(Solution::getNo).map(String::valueOf).collect(Collectors.joining(","));
        System.out.println(str);
    }
}
